package com.sqlcheck.service;

import com.sqlcheck.common.enums.DatabaseType;
import com.sqlcheck.dto.request.UnifiedAIAnalysisRequest;
import com.sqlcheck.dto.response.AIAnalysisResponse;
import com.sqlcheck.entity.CompatibilityRule;
import com.sqlcheck.model.SqlStatement;

import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;

/**
 * SQL批处理服务接口
 * 用于将大量SQL语句分批发送给LLM进行分析，避免超出上下文长度限制
 * 重构：基于 sql_statements 表记录进行批处理
 */
public interface SqlBatchProcessorService {

    /**
     * SQL批次信息
     * 修改：基于 SqlStatement 模型对象
     */
    class SqlBatch {
        private final int batchNumber;
        private final String batchContent;
        private final int estimatedTokens;
        private final List<SqlStatement> sqlStatements; // 改为 SqlStatement 对象

        public SqlBatch(int batchNumber, String batchContent, int estimatedTokens, List<SqlStatement> sqlStatements) {
            this.batchNumber = batchNumber;
            this.batchContent = batchContent;
            this.estimatedTokens = estimatedTokens;
            this.sqlStatements = sqlStatements;
        }

        public int getBatchNumber() {
            return batchNumber;
        }

        public String getBatchContent() {
            return batchContent;
        }

        public int getEstimatedTokens() {
            return estimatedTokens;
        }

        public List<SqlStatement> getSqlStatements() {
            return sqlStatements;
        } // 返回 SqlStatement 对象

        public int getStatementCount() {
            return sqlStatements.size();
        }
    }

    /**
     * 批处理进度信息
     */
    class BatchProgress {
        private final int currentBatch;
        private final int totalBatches;
        private final int processedStatements;
        private final int totalStatements;
        private final String currentStatus;

        public BatchProgress(int currentBatch, int totalBatches, int processedStatements,
                int totalStatements, String currentStatus) {
            this.currentBatch = currentBatch;
            this.totalBatches = totalBatches;
            this.processedStatements = processedStatements;
            this.totalStatements = totalStatements;
            this.currentStatus = currentStatus;
        }

        public int getCurrentBatch() {
            return currentBatch;
        }

        public int getTotalBatches() {
            return totalBatches;
        }

        public int getProcessedStatements() {
            return processedStatements;
        }

        public int getTotalStatements() {
            return totalStatements;
        }

        public String getCurrentStatus() {
            return currentStatus;
        }

        public double getProgressPercentage() {
            return totalStatements > 0 ? (double) processedStatements / totalStatements * 100 : 0;
        }
    }

    /**
     * 将SQL语句列表分批
     * 修改：基于 SqlStatement 对象列表
     * 
     * @param sqlStatements SQL语句列表
     * @param rules         兼容性规则
     * @param sourceDbType  源数据库类型
     * @param targetDbType  目标数据库类型
     * @return SQL批次列表
     */
    List<SqlBatch> splitIntoBatches(List<SqlStatement> sqlStatements, List<CompatibilityRule> rules,
            DatabaseType sourceDbType, DatabaseType targetDbType);

    /**
     * 批量分析SQL语句（基于SqlStatement列表，用于在线分析）
     * 
     * @param sqlStatements    SQL语句列表
     * @param request          AI分析请求
     * @param progressCallback 进度回调函数
     * @param analysisFunction 实际的分析函数，避免循环依赖
     * @return 合并后的分析结果
     */
    AIAnalysisResponse analyzeSqlInBatches(List<SqlStatement> sqlStatements, UnifiedAIAnalysisRequest request,
            Consumer<BatchProgress> progressCallback,
            Function<UnifiedAIAnalysisRequest, AIAnalysisResponse> analysisFunction);

    /**
     * 批量分析SQL语句
     * 修改：接收任务ID来加载 SqlStatement 记录
     * 
     * @param taskId           任务ID
     * @param request          AI分析请求
     * @param progressCallback 进度回调函数
     * @param analysisFunction 实际的分析函数，避免循环依赖
     * @return 合并后的分析结果
     */
    AIAnalysisResponse analyzeSqlInBatches(Long taskId, UnifiedAIAnalysisRequest request,
            Consumer<BatchProgress> progressCallback,
            Function<UnifiedAIAnalysisRequest, AIAnalysisResponse> analysisFunction);

    /**
     * 估算文本的token数量
     * 
     * @param text 待估算的文本
     * @return 估算的token数量
     */
    int estimateTokenCount(String text);

    /**
     * 合并多个批次的分析结果
     * 
     * @param batchResults 批次结果列表
     * @return 合并后的结果
     */
    AIAnalysisResponse mergeBatchResults(List<AIAnalysisResponse> batchResults);

    /**
     * 兼容性方法：支持基于文本内容的分批处理（手动SQL分析）
     * 
     * @param sqlContent   SQL内容文本
     * @param rules        兼容性规则
     * @param sourceDbType 源数据库类型
     * @param targetDbType 目标数据库类型
     * @return SQL批次列表
     */
    @Deprecated
    List<SqlBatch> splitIntoBatches(String sqlContent, List<CompatibilityRule> rules,
            DatabaseType sourceDbType, DatabaseType targetDbType);

    /**
     * 兼容性方法：检查是否需要进行批处理（基于文本内容）
     * 
     * @param sqlContent SQL内容
     * @return 是否需要批处理
     */
    @Deprecated
    boolean shouldUseBatchProcessing(String sqlContent);
}